package DataBase;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import AdministradorConfiguracion.AdminConfiguracion;

public class DBManager {

	// private DataBase db;
	private DBRedundancy db;

	public DBManager() {
		// this.db = new DataBase();
		Log.clear();
		this.db = new DBRedundancy(3);
	}

	/*
	 * public DBManager(DataBase nueva) { this.db = nueva; }
	 */

	/*
	 * public void datosPrueba() { Votante asa = new Votante("1234", "1234",
	 * "adrian", "perez", "false"); this.insertVotante(asa); Votante asa2 = new
	 * Votante("1235", "1235", "carlos", "gonzales", "false");
	 * this.insertVotante(asa2); Resultado r = new Resultado("presidente",
	 * "pepito"); this.insertPostulante(r); Resultado r2 = new
	 * Resultado("presidente", "juanchoto"); this.insertPostulante(r2);
	 * Resultado r3 = new Resultado("intendente", "mono programador");
	 * this.insertPostulante(r3); Administrador ad = new Administrador("222",
	 * "222", "repara", "dor", "987654"); this.insertAdministrador(ad);
	 * Autoridad au = new Autoridad("111", "111", "juan", "choto",
	 * "Presidente Titular"); this.insertAutoridad(au); Autoridad au2 = new
	 * Autoridad("123", "123", "Meme", "Rodriguez", "Presidente Suplente");
	 * this.insertAutoridad(au2); this.setPresidenteNuevo("123");
	 * 
	 * }
	 */

	public void datosPrueba() {
		insertVotante(new Votante("1234", "33885885", "Julian", "Chierichetti",
				"false"));
		insertVotante(new Votante("1235", "33885886", "Francisco", "Nose",
				"false"));
		insertVotante(new Votante("1236", "33885887", "Manuel", "Vacas",
				"false"));
		insertVotante(new Votante("1237", "33885888", "Valeria", "Moura Tuya",
				"false"));
		insertVotante(new Votante("1238", "33885889", "Federico", "Etchepare",
				"false"));
		insertVotante(new Votante("1239", "33885890", "Pedro", "Rigoli",
				"false"));
		insertVotante(new Votante("1240", "33885891", "Cesar Daniel", "Perez",
				"false"));
		insertVotante(new Votante("1241", "33885892", "Ignacio", "Lizarralde",
				"false"));

		insertAdministrador(new Administrador("222", "25000333", "El",
				"Administrador", "732894"));

		insertAutoridad(new Autoridad("123", "26111333", "El", "Presidente",
				"Presidente titular"));
		insertAutoridad(new Autoridad("124", "26111334", "El", "Presidentito",
				"Presidente suplente"));
		setPresidenteNuevo("123");

		new AdminConfiguracion(this);
	}

	public void limpiarDB() {
		this.db.limpiarDB();
	}

	// ///////////////////////////////////*VOTANTES*//////////////////////////////////////////////////////////

	private Votante createVotante(ResultSet rs) throws SQLException {
		// Recorre cada COLUMNA de la fila retornada
		if (rs.next()) {
			String f = rs.getString(5);
			if (f.equals("1"))
				f = "true";
			else
				f = "false";
			Votante v = new Votante(rs.getString(1), rs.getString(2),
					rs.getString(3), rs.getString(4), f);
			return v;
		}
		return (null);
	}

	public Votante getVotante(String pin) {
		ResultSet rs = db.consulta("SELECT * FROM votantes WHERE pin=" + pin
				+ ";");
		try {
			return this.createVotante(rs);
		} catch (SQLException ex) {/* error? */
		}
		return null;
	}

	private Hashtable<String, Votante> getHashVotantes(ResultSet rs)
			throws SQLException {
		Hashtable<String, Votante> retorno = new Hashtable<String, Votante>();
		while (rs.next()) {
			Votante v = new Votante(rs.getString(1), rs.getString(2),
					rs.getString(3), rs.getString(4), rs.getString(5));
			retorno.put(v.getDNI(), v);
		}
		return retorno;
	}

	public Hashtable<String, Votante> getVotantes() {
		ResultSet rs = db.consulta("SELECT * FROM votantes;");
		try {
			return this.getHashVotantes(rs);
		} catch (SQLException ex) {
			Logger.getLogger(DBManager.class.getName()).log(Level.SEVERE, null,
					ex);
		}
		return null;
	}

	public String insertVotante(Votante v) {
		if ((v.getPin().equals("")) || (v.getDNI().equals(""))
				|| (v.getApellido().equals("")) || (v.getNombre().equals(""))) {
			return ("Alguno de los campos obligatorios no ha sido completado");
		}
		String in1 = db
				.ejecutar("INSERT INTO votantes(pin, dni, apellido, nombre, finalizo)  VALUES ("
						+ v.getPin()
						+ ","
						+ v.getDNI()
						+ ",'"
						+ v.getApellido()
						+ "','"
						+ v.getNombre()
						+ "',"
						+ v.getFinalizo() + ");");
		return in1;
	}

	public String finalizoVoto(Votante v) {
		if ((v.getPin().equals("")) || (v.getDNI().equals(""))
				|| (v.getApellido().equals("")) || (v.getNombre().equals(""))) {
			return ("Alguno de los campos obligatorios no ha sido completado");
		}
		v.setFinalizo("true");
		String up1 = db.ejecutar("UPDATE votantes SET finalizo="
				+ v.getFinalizo() + " WHERE pin=" + v.getPin() + ";");
		return up1;
	}

	// ///////////////////////////////////*RESULTADOS*//////////////////////////////////////////////////////////

	private Resultado createResultado(ResultSet rs) throws SQLException {
		if (rs.next()) {
			Resultado r = new Resultado(rs.getString(1), rs.getString(2),
					rs.getString(3));
			return r;
		}
		return (null);
	}

	private Hashtable<String, Resultado> getHashResultados(ResultSet rs)
			throws SQLException {
		Hashtable<String, Resultado> retorno = new Hashtable<String, Resultado>();
		while (rs.next()) {
			Resultado r = new Resultado(rs.getString(1), rs.getString(2),
					rs.getString(3));
			retorno.put(r.getPuesto() + r.getCandidato(), r);
		}
		return retorno;
	}

	public String getResultadosParaTransmitir() {
		String resultados = "";
		/*
		 * for (Enumeration<Resultado> e = retorno.elements();
		 * e.hasMoreElements();) { Resultado fila = (Resultado) e.nextElement();
		 * resultados = resultados + fila.getPuesto() + ":" +
		 * fila.getCandidato() + ":" + fila.getVotos() + "-"; }
		 */

		for (Resultado r : getResultados()) {
			resultados += r + "\n";
		}

		return resultados;
	}

	public Resultado getResultado(String p, String c) {
		ResultSet rs = db.consulta("SELECT * FROM resultados WHERE puesto='"
				+ p + "' and candidato='" + c + "';");
		if (rs != null) {
			try {
				return this.createResultado(rs);
			} catch (SQLException ex) {/* error? */
			}
		}
		return null;
	}

	/*
	 * public Hashtable<String, Resultado> getResultados() { /* ResultSet rs =
	 * db.consulta("SELECT * FROM resultados;"); try { return
	 * this.getHashResultados(rs); } catch (SQLException ex) {
	 * Logger.getLogger(DBManager.class.getName()).log(Level.SEVERE, null, ex);
	 * } return null;
	 * 
	 * 
	 * ResultSet rs= db.consulta("SELECT * FROM resultados;"); try{ while
	 * (rs.next()){ Resultado r = new Resultado(rs.getString(1),
	 * rs.getString(2), rs.getString(3)); } } }
	 */

	public List<Resultado> getResultados() {
		ResultSet rs = db.consulta("SELECT * FROM resultados;");
		ArrayList<Resultado> resultados = new ArrayList<Resultado>();
		try {
			while (rs.next()) {
				resultados.add(new Resultado(rs.getString(1), rs.getString(2),
						rs.getString(3)));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return resultados;
	}

	public String insertPostulante(Resultado r) {
		if ((r.getPuesto().equals("")) || (r.getCandidato().equals(""))) {
			return ("Alguno de los campos obligatorios no ha sido completado");
		}
		String in1 = db
				.ejecutar("INSERT INTO resultados(puesto, candidato, votos)  VALUES ('"
						+ r.getPuesto() + "','" + r.getCandidato() + "',0);");
		return in1;
	}

	public String agregarVoto(String puesto, String candidato) {
		if ((puesto.equals("")) || (candidato.equals(""))) {
			return ("Alguno de los campos obligatorios no ha sido completado");
		}
		Resultado rAux = getResultado(puesto, candidato);
		int valor = Integer.parseInt(rAux.getVotos()) + 1;
		String up1 = db.ejecutar("UPDATE resultados SET votos=" + valor
				+ " WHERE puesto='" + puesto + "' and candidato='" + candidato
				+ "';");
		return up1;
	}

	// ///////////////////////////////////*AUTORIDADES*//////////////////////////////////////////////////////////

	private Autoridad createAutoridad(ResultSet rs) throws SQLException {
		if (rs.next()) {
			Autoridad a = new Autoridad(rs.getString(1), rs.getString(2),
					rs.getString(3), rs.getString(4), rs.getString(5));
			return a;
		}
		return (null);
	}

	public Autoridad getAutoridad(String pin) {
		ResultSet rs = db.consulta("SELECT * FROM autoridades WHERE pin=" + pin
				+ ";");
		try {
			return this.createAutoridad(rs);
		} catch (SQLException ex) {/* error? */
		}
		return null;
	}

	private Hashtable<String, Autoridad> getHashAutoridades(ResultSet rs)
			throws SQLException {
		Hashtable<String, Autoridad> retorno = new Hashtable<String, Autoridad>();
		while (rs.next()) {
			Autoridad v = new Autoridad(rs.getString(1), rs.getString(2),
					rs.getString(3), rs.getString(4), rs.getString(5));
			retorno.put(v.getDNI(), v);
		}
		return retorno;
	}

	public Hashtable<String, Autoridad> getAutoridades() {
		ResultSet rs = db.consulta("SELECT * FROM autoridades;");
		try {
			return this.getHashAutoridades(rs);
		} catch (SQLException ex) {
			Logger.getLogger(DBManager.class.getName()).log(Level.SEVERE, null,
					ex);
		}
		return null;
	}

	public String insertAutoridad(Autoridad a) {
		if ((a.getPin().equals("")) || (a.getDNI().equals(""))
				|| (a.getApellido().equals("")) || (a.getNombre().equals(""))
				|| (a.getPosicion().equals(""))) {
			return ("Alguno de los campos obligatorios no ha sido completado");
		}
		String in1 = db
				.ejecutar("INSERT INTO autoridades(pin, dni, apellido, nombre, posicion)  VALUES ("
						+ a.getPin()
						+ ","
						+ a.getDNI()
						+ ",'"
						+ a.getApellido()
						+ "','"
						+ a.getNombre()
						+ "','"
						+ a.getPosicion() + "');");
		return in1;
	}

	public void setPresidenteNuevo(Autoridad pNuevo) {
		db.ejecutar("UPDATE autoridades SET posicion='Presidente Suplente' WHERE posicion='Presidente Titular';");
		pNuevo.setPosicion("Presidente Titular");
		insertAutoridad(pNuevo);
	}

	public void setPresidenteNuevo(String pinTitularNuevo) {
		db.ejecutar("UPDATE autoridades SET posicion='Presidente Suplente' WHERE posicion='Presidente Titular';");
		db.ejecutar("UPDATE autoridades SET posicion='Presidente Titular' WHERE pin='"
				+ pinTitularNuevo + "';");
	}

	public Autoridad getPresidenteTitular() {
		ResultSet rs = db
				.consulta("SELECT * FROM autoridades WHERE posicion='Presidente Titular';");
		try {
			return this.createAutoridad(rs);
		} catch (SQLException ex) {/* error? */
		}
		return null;
	}

	public Autoridad getPresidenteSuplente() {
		ResultSet rs = db
				.consulta("SELECT * FROM autoridades WHERE posicion='Presidente Suplente';");
		try {
			return this.createAutoridad(rs);
		} catch (SQLException ex) {/* error? */
		}
		return null;
	}

	// ///////////////////////////////////*ADMINISTRADORES*//////////////////////////////////////////////////////////
	private Administrador createAdministrador(ResultSet rs) throws SQLException {
		if (rs.next()) {
			Administrador a = new Administrador(rs.getString(1),
					rs.getString(2), rs.getString(3), rs.getString(4),
					rs.getString(5));
			return a;
		}
		return (null);
	}

	public Administrador getAdministrador(String pin) {
		ResultSet rs = db.consulta("SELECT * FROM administradores WHERE pin="
				+ pin + ";");
		if (rs != null) {
			try {
				return this.createAdministrador(rs);
			} catch (SQLException ex) {/* error? */
			}
		}
		return null;
	}

	private Hashtable<String, Administrador> getHashAdministradores(ResultSet rs)
			throws SQLException {
		Hashtable<String, Administrador> retorno = new Hashtable<String, Administrador>();
		while (rs.next()) {
			Administrador v = new Administrador(rs.getString(1),
					rs.getString(2), rs.getString(3), rs.getString(4),
					rs.getString(5));
			retorno.put(v.getDNI(), v);
		}
		return retorno;
	}

	public Hashtable<String, Administrador> getAdministradores() {
		ResultSet rs = db.consulta("SELECT * FROM administradores;");
		try {
			return this.getHashAdministradores(rs);
		} catch (SQLException ex) {
			Logger.getLogger(DBManager.class.getName()).log(Level.SEVERE, null,
					ex);
		}
		return null;
	}

	public String insertAdministrador(Administrador a) {
		if ((a.getPin().equals("")) || (a.getDNI().equals(""))
				|| (a.getApellido().equals("")) || (a.getNombre().equals(""))
				|| (a.getTelefono().equals(""))) {
			return ("Alguno de los campos obligatorios no ha sido completado");
		}
		String in1 = db
				.ejecutar("INSERT INTO administradores(pin, dni, apellido, nombre, telefono)  VALUES ("
						+ a.getPin()
						+ ","
						+ a.getDNI()
						+ ",'"
						+ a.getApellido()
						+ "','"
						+ a.getNombre()
						+ "','"
						+ a.getTelefono() + "');");
		return in1;
	}

	public void romperActiva() {
		db.romperActiva();
	}

	public void dropDB() {
		db.dropDataBase();
	}
}